package 动态规划.另类的;

/**
 * @author aodre , QQ : 480029069
 * @date 2023/1/4 13:23
 */
public class leetcode674最长连续上升子序列 {

    /*
      不可能存在 写不出来  递归的 dp 的

      首先 思考 f 函数的 意义 ,以及依赖关系
     */




    /*
     f(index) 表示的 以 index 开头的 最长的 连续的 子序列的长度
     那么 f(index) 与 f(index + 1) 之间的 关系 就出来 了
     但是 这个 问题 还是 这里
     这个 递归 函数 一次 只能 求 一个  f(index)
     但是 改成 dp 之后 , 就出来了!
     */
    public int recursion(int index,int []nums){
        /*
         如果 这里写的是
         index == nums.length
         下面的 就需要 进行逻辑的 判断了,否则 会出现  数组越界的异常!
         但是 写 这个  index == nums.length - 1
         的话, 就不 需要 了

         -- 这也体现了一种  basecase 的 书写 艺术( 确实 一种 艺术 )
         合理的basecase
         */
        if(index == nums.length - 1){
            return 1;
        }
        int ans = 1;
        // 这里需要进行边界的判断
        if(nums[index] < nums[index + 1]){
            ans = recursion(index + 1,nums) + 1;
        }
        return ans;
    }
    //dp ,
    public int dp(int [] nums){
        int len = nums.length;
        int dp [] = new int[len];
        dp[len - 1] = 1;
        int max = 1;
        for(int index = len - 2;index >= 0;index --){
            dp[index] = 1;
            if(nums[index] < nums[index + 1]){
                dp[index] = dp[index + 1] + 1;
            }
            max = Math.max(max,dp[index]);
        }
        return max;
    }

// 最初的写法!
    public int findLengthOfLCIS(int[] nums) {
        int ans = 0;
        int count = 1;
        for(int i = 0;i < nums.length - 1;i++){
            if(nums[i] >= nums[i + 1]){
                count = 1;
            }
            else{
                count ++;
            }
            ans = Math.max(ans,count);
        }
        return ans >= count ? ans : count;
    }
}
